Add Bitbucket adapter - #125

Bitbucket identifies a hook by UUID, which an int return cannot carry, so
createWebhook() threw and a separate createRepositoryWebhook() returned the
UUID. Widening the return to int|string lets Bitbucket implement the same
method every other adapter does.

Bitbucket declares the parts of the contract it does not offer - presigned
archive urls, check runs, namespace listing, computed languages, user
lookup by handle, webhook delivery to the catcher, and file lists in a
push event - and keeps only the tests describing itself: workspaces, uuid
webhooks and user lookups, multi-ref pushes, and its action mapping.

The event payload builders replace hand-written getEvent tests, so the
shared assertions cover them, and Base's repository id is now overridable
because Bitbucket routes on "workspace/slug" rather than a numeric id.

getEvent() returned an empty event for a malformed payload rather than
throwing, as the other adapters do.

resolveRef() above already catches Exception and converts it to
FileNotFound() for the expected "file/ref doesn't exist" case, but the
two call() invocations below it didn't -- so a 404 whose response
body doesn't decode as JSON (a real, common case: not every repo has
package.json) propagated as an uncaught fatal, crashing the whole
Swoole worker (confirmed live) rather than resulting in a normal
FileNotFound for this one lookup.

Was missing entirely, throwing the base Git class's "not supported"
default -- confirmed live, this crashed VCS site/function deployments
outright (Compute/Base.php calls it unconditionally for every
provider). Bitbucket's archive download lives on the browser host,
not the API host, and only supports zip/gz/bz2 (no "tarball"
extension distinct from gz). Auth is URL-embedded the same way
generateCloneCommand() already does it, since this URL is handed off
for a plain download rather than called with a bearer header.

The method name collided with Base::testGetUser(), so PHPUnit ran only
Bitbucket's override and never reached Base's skipUnlessSupported()
check -- meaning $supportsUserLookup = false correctly skipped
testGetUserWithInvalidUsername but silently did nothing for testGetUser.
Renamed to testGetUserByUuid so it no longer overrides a Base test by
name, matching every other adapter's tests (none of which redefine a
Base method -- they only add new ones or override the hook methods
Base already exposes for this).

…adapter

An exhaustive pass over the diff turned up more of what earlier rounds
already fixed piecemeal:

Duplication:
- resolveRef() and resolveDefaultBranch() repeated the same mainbranch
  lookup, differing only in the empty case -> mainBranchName().
- listSource() and getRepositoryContent() repeated the resolveRef/
  normalize/build-/src/-url preamble verbatim -> sourceUrl().
- normalizeRepository() and getEventRepositoryOwner() both derived the
  workspace slug with a full_name fallback -> workspaceSlugOf().
- searchRepositories() re-implemented the id/private/pushed_at mapping
  normalizeRepository() exists to centralize; it now runs through it.
- getRepositoryName() re-issued the request getRepository() already
  makes; it now splits the "workspace/slug" id and delegates.
- The "no numeric repository ids" note was stated six times; it is now
  stated once, in normalizeRepository() where the id is minted.

Dead code:
- setBitbucketUrl() had no caller anywhere.
- $refreshToken was assigned and never read.
- getEventRepositoryId() wrapped a single strval(); inlined.
- Base's $supportsPresignedUrls was never set false by any adapter, so
  both branches it guarded were unreachable.
- BitbucketTest read TESTS_BITBUCKET_ENDPOINT, which no compose file,
  workflow or doc sets.

Consistency with the sibling adapters:
- $body -> $responseBody, $SHA -> $commitHash.
- listRepositoryLanguages() returns [] for a missing repository rather
  than throwing, matching the other list-style getters.
- Dropped defensive is_array() ternaries where plain ?? [] is what
  GitHub/GitLab/Gitea write, and docblocks that restated the method
  name or the contract in Adapter.php.
- The inverted skipUnlessSupported(!$flag, ...) in Base now reads as a
  plain markTestSkipped with a message that says what is happening.

…us urls

Two correctness bugs the shared suite can't currently catch, because the
bitbucket CI job skips every test for want of credentials:

- getRepositoryName() returned Bitbucket's free-form display `name`, not
  the `slug` its API routes on and every other method here takes as
  $repositoryName. GitLab has the same split and deliberately returns
  `path`; on GitHub and Gitea the two are the same value, so Bitbucket
  was the one adapter that picked the non-routable field. Any repository
  whose display name isn't already slug-form ("My Site" vs "my-site")
  would 404 clone, branch and commit-status calls downstream. Base can't
  see it: createRepository() posts name == slug, so the two never differ
  for anything the suite creates.
- getRepositoryContent() reported the last-touching commit hash as `sha`,
  where Base::testGetRepositoryContentReportsBlobSha (ungated, shared)
  asserts it is the git blob id, and GitHub/GitLab/Gitea all return a
  real one. The adapter has the bytes, so it now computes the blob id
  git itself stores rather than substituting a different hash.

Also:
- Adapter::getEvents() default returned [[]] for an event the adapter
  doesn't report, where an overriding adapter returns []. It now drops
  the empty event so the two agree.
- Base asserted a numeric webhook id in one of the three places it
  checks one, left over from before the contract widened to int|string.
- Bitbucket's bespoke commit-status test re-ran Base::testGetCommitStatuses
  verbatim to change one assertion; Base now exposes an
  assertCommitStatusUrl() hook (no-op default) that BitbucketTest fills
  in, dropping a whole repository round trip.
- Inlined the last single-use helpers (resolveRef and encodeRepositoryPath
  into sourceUrl, resolveDefaultBranch into createFile,
  getEventRepositoryOwner into its two callers).

An OAuth consumer is free where a workspace access token may not be, and
the token it hands back lasts two hours, so CI mints one before starting
the stack rather than keeping a long-lived credential around. The value
goes straight into GITHUB_ENV, masked, and is never stored as a secret --
only the consumer's client id and secret are, since minting has to
authenticate as the consumer.

With no consumer configured the step is a no-op and the suite skips, the
same as it does today.

Also documents in CONTRIBUTING why an Atlassian account API token (the
ATATT kind) answers 401 here: it authenticates as email:token over HTTP
Basic, and the adapter sends the token as a Bearer credential.

curl -sf discards the error body, so a refused token request surfaced as
a bare "could not mint" with nothing to act on. Captures the status and
body instead and echoes Bitbucket's own error_description.

createRepository() reported only the status code, so a 400 gave nothing
to act on. createWebhook() already includes the response body; this
matches it.

CI mints its own token, so the manual steps were setup lore rather than
something a contributor needs in the repo.

EVENT_REPOSITORY_ID is the one EVENT_* fact an adapter overrides, so it
is the only one that needs late static binding to resolve. The other
eight were changed for consistency and are churn this PR doesn't need.

createFile() defaulted an empty repository's branch to 'main' on the
belief that Bitbucket names the first branch after whatever the commit
asks for. It doesn't -- the commit lands on Bitbucket's own default and
'main' never exists, so every later call that named it failed: 404 from
getLatestCommit(), 400 from createBranch() resolving it as a target, and
empty results from listSource(), which swallows the 404 into [].

It only ever surfaced now because the suite skipped for want of
credentials until this run.

Omits the branch when there is none to name, letting Bitbucket create
its default, and declares that default as 'master' in BitbucketTest the
way GogsTest already does for Gogs.

The adapter only spoke Bearer, so an Atlassian account API token -- the
ATATT kind, which authenticates as email:token over HTTP Basic -- answered
401 on every call, and testing meant standing up an OAuth consumer with
the client-credentials grant enabled.

An email:token pair always carries a colon and a bare token never does, so
the credential names its own scheme and initializeVariables() keeps its
signature. Centralising the header also collapses 26 copies of
'Bearer ' . $this->accessToken into one place, and clone/archive URLs
reuse the same distinction: an email:token pair is already valid userinfo,
where a bare token needs the x-token-auth username Bitbucket pairs it with.

CI drops the minting step it needed for client credentials and passes
TESTS_BITBUCKET_ACCESS_TOKEN straight through again.

A bare token and an email:token pair fail very differently, and the 401
they produce looks the same from the outside. Reports the shape -- never
the value -- so a misformed secret is obvious rather than inferred.

The endpoint answers with workspace_access objects that carry the
workspace under its own key:

  {"type":"workspace_access","administrator":true,
   "workspace":{"slug":"utopiavcs", ...}}

getOwnerName() read $values[0]['slug'], which is never set, so it always
fell through to the account handle -- and Bitbucket's repository API
does not accept a handle as a workspace, so every call built from it
answered 404. The nested read was there originally; I removed it while
trimming comments, on the mistaken belief that it covered an endpoint
this code never calls. It is the only shape this endpoint returns.

A minting step was overwriting TESTS_BITBUCKET_ACCESS_TOKEN with a token
minted from the OAuth consumer, so the configured credential was never
used: CI authenticated as the consumer, resolved the consumer's
workspace, and answered 403 against any other. Removes it, along with
the credential-shape check that existed only to debug that confusion.

The endpoint rejects a page parameter -- "Invalid page", HTTP 400 -- and
pages instead by handing back the url of the next page. listSource()
asked for ?pagelen=100&page=1, so every listing failed, and because it
read any error as an empty listing the failure surfaced as
getRepositoryTree() and listRepositoryContents() quietly returning
nothing at all.

Follows the next url as given, and reports a failed listing rather than
answering it with an empty array: only a 404, meaning the ref or path
genuinely isn't there, is still an empty result. Silently swallowing the
400 is what kept this hidden.

getRepositoryTree() answered nothing for a branch like feature/test, because
sourceUrl() percent-encoded the ref and Bitbucket matches a nested branch
name against the path as written -- feature%2Ftest names no ref.

getRepositoryPresignedUrl() already kept its slashes for exactly this
reason, so the three places a ref reaches a path now share one encodeRef()
rather than two of them disagreeing. getLatestCommit() had the same fault
with no test to catch it.

getRepositoryTree() answered nothing for a branch like feature/test.
Bitbucket takes the ref as one path segment, so the name read as the ref
`feature` and the path `test`; percent-encoding the slash didn't separate
them either, as the endpoint matches the ref against the path as written.

The three places a ref reaches a url -- source listings, latest commit and
the archive url -- now resolve a nested name to its hash first, which names
the same commit with nothing left to misread. Names without a slash are
passed through untouched, so the usual case still costs one request.

The id came from a hook the adapters overrode, which named a pattern two
call sites don't need. Both read it off the repository as it comes.

Trims the prose around the check runs and the ref lookup to the one or two
lines the rest of the file spends, dropping what restated the code and the
url note updateCommitStatus already carries.

The id names a workspace and a slug either side of a slash, and travels as
one path segment, so callers encode that slash. Nothing decoded it, leaving
getRepositoryName() to look for a separator that was no longer there and
report every Bitbucket repository as missing.

An id that arrives with its slash intact carries no escapes, so it comes
back through unchanged.

main now asks every adapter for the events a delivery describes, so the
wrapper this branch carried and the single-event read Bitbucket kept beside
it both describe what the contract already says.